# -*- coding: latin-1 -*-
#=========================================================================================
import os

from PyQt4 import QtCore, QtGui

import Code.ControlPosicion as ControlPosicion
import Code.Util as Util
import Code.VarGen as VarGen
import Code.TrListas as TrListas

import Code.QT.Iconos as Iconos
import Code.QT.Controles as Controles
import Code.QT.Colocacion as Colocacion
import Code.QT.QTUtil as QTUtil
import Code.QT.QTUtil2 as QTUtil2
import Code.QT.Tablero as Tablero
import Code.QT.PantallaTabVFlechas as PantallaTabVFlechas
import Code.QT.QTVarios as QTVarios

import Code.QT.FormLayout as FormLayout

#=========================================================================================
class BotonTema(QtGui.QPushButton):
    def __init__(self, parent, rutina):
        QtGui.QPushButton.__init__(self, parent)

        self.setFixedSize(64, 64)
        self.qs = QtCore.QSize(64, 64)
        self.setIconSize(self.qs)

        self.rutina = rutina
        self.tema = None

        self.connect(self, QtCore.SIGNAL("clicked()"), self.pulsado )

    def ponTema( self, tema ) :
        self.setVisible( tema is not None )
        self.tema = tema
        if not tema :
            return
        self.setToolTip( tema["NOMBRE"] )
        self.setIcon(QTVarios.iconoTema(tema,64))

    def pulsado(self):
        self.rutina( self.tema )

#=========================================================================================
class BotonColor(QtGui.QPushButton):
    def __init__(self, parent, nombre, rutina, ncolor, ancho, alto ):
        QtGui.QPushButton.__init__(self, parent)

        self.setFixedSize(ancho, alto)
        self.ancho = ancho
        self.alto = alto

        self.rutina = rutina
        self.connect(self, QtCore.SIGNAL("clicked()"), self.pulsado )

        self.nombre = nombre

        self.ponColor( ncolor )

    def ponColor( self, ncolor ) :
        self.setStyleSheet("QWidget { background: %s }"%QTUtil.qtColor(ncolor).name())

    def pulsado(self):
        self.rutina( self.nombre )

#=========================================================================================

#=========================================================================================
class WColores( QtGui.QDialog ) :
    #--------------------------------------------------------------------------------------------------------------------------------
    def __init__( self, tableroOriginal ) :
        super(WColores, self).__init__(tableroOriginal.parent())

        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint )

        self.tableroOriginal = tableroOriginal
        self.configuracion = VarGen.configuracion
        self.confTablero = tableroOriginal.confTablero.copia(tableroOriginal.confTablero._id)
        self.siBase = tableroOriginal.confTablero._id == "BASE"

        self.setWindowTitle( _( "Colours" ) )
        self.setWindowIcon( Iconos.EditarColores() )

        # Temas #############################################################################################################################
        liOpciones = [ (_("Your themes"), self.configuracion.ficheroTemas ) ]
        for x in os.listdir( "Themes" ) :
            if x.endswith( "lktheme" ) :
                ctema = x[:-8]
                liOpciones.append( (ctema, "Themes/"+x ) )

        self.cbTemas = Controles.CB( liOpciones, liOpciones[0][1] ).capturaCambiado( self, self.cambiadoTema )
        self.lbSecciones = Controles.LB( _("Section") + " :")
        self.cbSecciones = Controles.CB( [], None ).capturaCambiado( self, self.cambiadoSeccion )

        lyTemas = Colocacion.G()
        self.liBT_Temas = []
        for i in range(12) :
            for j in range(6) :
                bt = BotonTema( self, self.ponTema )
                lyTemas.control(bt,i,j)
                bt.ponTema( None )
                self.liBT_Temas.append(bt)

        def creaLB( txt ) :
            return Controles.LB( txt + ": ").alinDerecha()

        # Actual
        self.chbTemas = Controles.CHB( _("Default"), self.confTablero.siDefTema() ).capturaCambiado( self, self.defectoTemas )
        if self.siBase :
            self.chbTemas.ponValor( False )
            self.chbTemas.setVisible( False )
        #Exterior
        lbExterior = creaLB( _( "Outer Border" ) )
        self.btExterior = BotonColor( self, "E", self.ponActual, self.confTablero.colorExterior(), 164, 24 )
        #Blancas
        lbBlancas = creaLB( _( "White squares" ) )
        self.btBlancas = BotonColor( self, "B", self.ponActual, self.confTablero.colorBlancas(), 164, 24 )
        #Negras
        lbNegras = creaLB( _( "Black squares" ) )
        self.btNegras = BotonColor( self, "N", self.ponActual, self.confTablero.colorNegras(), 164, 24 )
        #Texto
        lbTexto = creaLB( _( "Coordinates" ) )
        self.btTexto = BotonColor( self, "T", self.ponActual, self.confTablero.colorTexto(), 164, 24 )
        #Frontera
        lbFrontera = creaLB( _( "Inner Border" ) )
        self.btFrontera = BotonColor( self, "F", self.ponActual, self.confTablero.colorFrontera(), 164, 24 )
        #Flecha
        lbFlecha = creaLB ( _( "Move indicator" ) )
        self.btFlecha = Controles.PB( self, "---------->", self.cambiaFlecha, plano = False )
        self.btFlechaDefecto = Controles.PB( self, "", self.flechaDefecto ).ponIcono( Iconos.Motor_No() )
        lyF = Colocacion.H().control(self.btFlecha).control(self.btFlechaDefecto).relleno(1)

        #Flecha Alternativa
        lbFlechaAlternativa = creaLB ( _( "Arrow alternative" ) )
        self.btFlechaAlternativa = Controles.PB( self, "- - - - - >", self.cambiaFlechaAlternativa, plano = False )
        self.btFlechaDefectoAlternativa = Controles.PB( self, "", self.flechaDefectoAlternativa ).ponIcono( Iconos.Motor_No() )
        lyFAlternativa = Colocacion.H().control(self.btFlechaAlternativa).control(self.btFlechaDefectoAlternativa).relleno(1)

        lyActual = Colocacion.G()
        lyActual.control( self.chbTemas, 0, 0 )
        lyActual.control( lbBlancas, 1, 0, alineacion = "d" ).control( self.btBlancas, 1, 1 )
        lyActual.control( lbNegras, 2, 0, alineacion = "d" ).control( self.btNegras, 2, 1 )
        lyActual.control( lbTexto, 3, 0, alineacion = "d" ).control( self.btTexto, 3, 1 )
        lyActual.control( lbExterior, 4, 0, alineacion = "d" ).control( self.btExterior, 4, 1 )
        lyActual.control( lbFrontera, 5, 0, alineacion = "d" ).control( self.btFrontera, 5, 1 )
        lyActual.control( lbFlecha, 6, 0, alineacion = "d" ).otro( lyF, 6, 1 )
        lyActual.control( lbFlechaAlternativa, 7, 0, alineacion = "d" ).otro( lyFAlternativa, 7, 1 )

        gbActual = Controles.GB(self,_("Active theme"),lyActual)

        lySecciones = Colocacion.H().control(self.lbSecciones).control(self.cbSecciones).relleno(1)
        ly = Colocacion.V().control(self.cbTemas).otro(lySecciones).otro(lyTemas).control(gbActual).relleno(1)
        gbTemas = Controles.GB(self,"",ly)
        gbTemas.setFlat(True)

        # mas opciones ##############################################################################################################
        def xDefecto( siDefecto ) :
            if self.siBase :
                siDefecto = False
            chb = Controles.CHB( _("Default"), siDefecto).capturaCambiado( self, self.defectoTableroM )
            if self.siBase :
                chb.setVisible(False)
            return chb

        def l2mas1( lyG, fila, a,b,c ) :
            if a :
                ly = Colocacion.H().controld(a).control(b)
            else :
                ly = Colocacion.H().control(b)
            lyG.otro(ly,fila,0).control(c,fila,1)

        # Coordenadas
        lyG = Colocacion.G()
        ## _nCoordenadas
        lbCoordenadas = creaLB( _( "Number" ) )
        liOpciones = [ ("0",0), ("4",4), ("2a",2), ("2b",3), ("2c",5), ("2d",6) ]
        self.cbCoordenadas = Controles.CB( liOpciones, self.confTablero.nCoordenadas() ).capturaCambiado( self, self.actualizaTableroM )
        self.chbDefCoordenadas = xDefecto( self.confTablero.siDefCoordenadas() )
        l2mas1( lyG, 0, lbCoordenadas, self.cbCoordenadas, self.chbDefCoordenadas )

        ## _tipoLetra
        lbTipoLetra = creaLB( _( "Font" ) )
        self.cbTipoLetra = QtGui.QFontComboBox()
        self.cbTipoLetra.setEditable(False)
        self.cbTipoLetra.setFontFilters( self.cbTipoLetra.ScalableFonts)
        self.cbTipoLetra.setCurrentFont(QtGui.QFont(self.confTablero.tipoLetra()) )
        self.connect( self.cbTipoLetra, QtCore.SIGNAL("currentIndexChanged(int)"), self.actualizaTableroM )
        self.chbDefTipoLetra = xDefecto( self.confTablero.siDefTipoLetra() )
        l2mas1( lyG, 1, lbTipoLetra, self.cbTipoLetra, self.chbDefTipoLetra )

        ## _cBold
        self.chbBold = Controles.CHB( _("Bold"), self.confTablero.siBold()).capturaCambiado( self, self.actualizaTableroM )
        self.chbDefBold = xDefecto( self.confTablero.siDefBold() )
        l2mas1( lyG, 2, None, self.chbBold, self.chbDefBold )

        ## _tamLetra
        lbTamLetra = creaLB( _("Size") + " %" )
        self.sbTamLetra = Controles.SB( self.confTablero.tamLetra(), 1, 200 ).tamMaximo( 50 ).capturaCambiado(self.actualizaTableroM)
        self.chbDefTamLetra = xDefecto( self.confTablero.siDefTamLetra() )
        l2mas1( lyG, 3, lbTamLetra, self.sbTamLetra, self.chbDefTamLetra )

        ## _sepLetras
        lbSepLetras = creaLB( _("Separation") + " %" )
        self.sbSepLetras = Controles.SB( self.confTablero.sepLetras(), -1000, 1000 ).tamMaximo( 50 ).capturaCambiado(self.actualizaTableroM)
        self.chbDefSepLetras = xDefecto( self.confTablero.siDefSepLetras() )
        l2mas1( lyG, 4, lbSepLetras, self.sbSepLetras, self.chbDefSepLetras )

        gbCoordenadas = Controles.GB(self,_("Coordinates"),lyG)

        lyOtros = Colocacion.G()
        ## _nomPiezas
        li = []
        lbPiezas = creaLB( _("Pieces") )
        for x in os.listdir( "Pieces" ) :
            if os.path.isdir( "Pieces/%s"%x ) :
                li.append( (x,x) )
        li.sort(key=lambda x: x[0] )
        self.cbPiezas = Controles.CB( li, self.confTablero.nomPiezas() ).capturaCambiado( self, self.actualizaTableroM )
        self.chbDefPiezas = xDefecto( self.confTablero.siDefPiezas() )
        l2mas1( lyOtros, 0, lbPiezas, self.cbPiezas, self.chbDefPiezas )

        ## _tamRecuadro
        lbTamRecuadro = creaLB( _("Outer Border Size") + " %" )
        self.sbTamRecuadro = Controles.SB( self.confTablero.tamRecuadro(), 0, 10000 ).tamMaximo( 50 ).capturaCambiado(self.actualizaTableroM)
        self.chbDefTamRecuadro = xDefecto( self.confTablero.siDefTamRecuadro() )
        l2mas1( lyOtros, 1, lbTamRecuadro, self.sbTamRecuadro, self.chbDefTamRecuadro )

        ## _tamFrontera
        lbTamFrontera = creaLB( _("Inner Border Size") + " %" )
        self.sbTamFrontera = Controles.SB( self.confTablero.tamFrontera(), 0, 10000 ).tamMaximo( 50 ).capturaCambiado(self.actualizaTableroM)
        self.chbDefTamFrontera = xDefecto( self.confTablero.siDefTamFrontera() )
        l2mas1( lyOtros, 2, lbTamFrontera, self.sbTamFrontera, self.chbDefTamFrontera )

        ly = Colocacion.V().control(gbCoordenadas).espacio(50).otro(lyOtros).relleno(1)

        gbOtros = Controles.GB(self,"",ly)
        gbOtros.setFlat(True)

        # Tablero ##########################################################################################################################
        cp = ControlPosicion.ControlPosicion().leeFen( "2kr1b1r/2p1pppp/p7/3pPb2/1q3P2/2N1P3/PPP3PP/R1BQK2R w KQ - 0 1" )
        self.tablero = Tablero.Tablero(self, self.confTablero, siMenuVisual = False)
        self.tablero.crea()
        self.tablero.ponPosicion( cp )
        self.rehazFlechas()

        # tb = QTUtil2.creaTBAceptarCancelar( self )
        liAcciones = [  ( _( "Accept" ), Iconos.Aceptar(), "aceptar" ),
                        None,
                        ( _( "Cancel" ), Iconos.Cancelar(), "cancelar" ),
                        None,
                        ( _( "Your themes" ), Iconos.Temas(), "temas" ),
                        ]
        tb = Controles.TB( self, liAcciones )

        # Juntamos
        lyT = Colocacion.V().control( tb ).espacio(15).control( self.tablero ).relleno(1).margen(3)

        self.tab = Controles.Tab()
        self.tab.nuevaTab( gbTemas, _("Themes" ) )
        self.tab.nuevaTab( gbOtros, _("Other options" ) )
        ly = Colocacion.H().otro( lyT ).control(self.tab)

        self.setLayout( ly )

        self.elegido = None

        self.liTemas = self.leeTemas()
        self.temaActual = None
        if self.liTemas :
            txt = self.confTablero.graba()
            for tema in self.liTemas :
                if tema :
                    if tema.get("TEXTO","") == txt :
                        self.temaActual = tema
                        break
        self.cambiadoTema()

        self.siActualizando = False

    #--------------------------------------------------------------------------------------------------------------------------------
    def rehazFlechas( self ) :
        self.tablero.quitaFlechas()
        siMain = True
        for d, h in ( ("d7", "f5"),("b4","c4"),("d7","c6"),("b4","b6"),) :
            self.tablero.creaFlechaTmp( d, h, siMain )
            siMain = False

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiadoTema( self ) :
        fichTema = self.cbTemas.valor()
        self.liTemasTMP = Util.recuperaVar(fichTema)
        if not self.liTemasTMP :
            self.cbTemas.ponValor( "Themes/Felicia.lktheme" )
            self.cambiadoTema()
        else :
            self.ponSecciones()
            self.cambiadoSeccion()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponSecciones( self ) :
        previo = self.cbSecciones.valor()
        liOpciones = []
        liFolders = []
        for n,uno in enumerate(self.liTemasTMP) :
            if uno :
                if "SECCION" in uno :
                    folder = uno["SECCION"]
                    if folder not in liFolders :
                        liFolders.append(folder)
                        liOpciones.append( (folder,folder) )

        liOpciones.append( (_("All"),None) )

        select = previo if previo in liFolders else liOpciones[0][1]
        self.cbSecciones.rehacer( liOpciones, select )
        siVisible = len(liOpciones) > 1
        self.cbSecciones.setVisible(siVisible)
        self.lbSecciones.setVisible(siVisible)

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiadoSeccion( self ) :
        seccionBusca = self.cbSecciones.valor()

        nPos = 0
        for nTema,tema in enumerate(self.liTemasTMP) :
            if tema :
                seccion = tema.get("SECCION", None )

                if (seccionBusca is None) or (seccion==seccionBusca) :
                    self.liBT_Temas[nPos].ponTema(tema)
                    nPos += 1

        for x in range(nPos,len(self.liBT_Temas)) :
            self.liBT_Temas[x].ponTema(None)

    #--------------------------------------------------------------------------------------------------------------------------------
    def defectoTemas( self ) :
        siDefecto = self.chbTemas.valor()
        self.confTablero.ponDefTema(siDefecto)
        self.btExterior.setDisabled( siDefecto )
        self.btBlancas.setDisabled( siDefecto )
        self.btNegras.setDisabled( siDefecto )
        self.btTexto.setDisabled( siDefecto )
        self.btFrontera.setDisabled( siDefecto )
        self.btFlecha.setDisabled( siDefecto )
        self.btFlechaDefecto.setDisabled( siDefecto )
        self.actualizaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        if accion == "aceptar" :

            self.confTablero.guardaEnDisco()
            self.tableroOriginal.reset( self.confTablero )

            self.accept()
        elif accion == "cancelar" :
            self.reject()

        elif accion == "temas" :
            self.temas()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponActual( self, clave ) :
        dic = { "E":"Exterior", "B":"Blancas", "N":"Negras", "T":"Texto", "F":"Frontera" }
        rgba_color = getattr( self.confTablero, "color"+dic[clave] )
        color = QtGui.QColor(rgba_color())
        color = QtGui.QColorDialog.getColor(color, self, _( "Choose a colour" ) )
        if color.isValid() :
            self.sinElegir = False
            rgba_color( color.rgba() )
            self.actualizaTablero()
    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaFlecha( self ) :
        w = PantallaTabVFlechas.WTV_Flecha( self, self.tablero.confTablero.fTransicion(), False )
        if w.exec_() :
            self.confTablero.fTransicion( w.regFlecha )
            self.actualizaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaFlechaAlternativa( self ) :
        w = PantallaTabVFlechas.WTV_Flecha( self, self.tablero.confTablero.fAlternativa(), False )
        if w.exec_() :
            self.confTablero.fAlternativa( w.regFlecha )
            self.actualizaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def flechaDefecto( self ) :
        self.confTablero.fTransicion( self.confTablero.flechaDefecto() )
        self.actualizaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def flechaDefectoAlternativa( self ) :
        self.confTablero.fAlternativa( self.confTablero.flechaDefectoAlternativa() )
        self.actualizaTablero()

    # --------------------------------------------------------------------------------------------------------------------------------
    def ponTema( self, tema ) :
        self.chbTemas.ponValor( False )
        self.defectoTemas()
        self.sinElegir = False
        self.confTablero.leeTema(tema.get("TEXTO",""))
        self.actualizaTablero()

    #--------------------------------------------------------------------------------------------------------------------------------
    def defectoTableroM( self ) :
        if self.siActualizando :
            return
        self.siActualizando = True

        self.actualizaTableroM()

        ct = self.confTablero
        for chb, obj, xv in (
                (self.chbDefCoordenadas, self.cbCoordenadas, ct.nCoordenadas ),
                (self.chbDefBold, self.chbBold, ct.siBold ),
                (self.chbDefTamLetra, self.sbTamLetra, ct.tamLetra ),
                (self.chbDefSepLetras, self.sbSepLetras, ct.sepLetras ),
                (self.chbDefPiezas, self.cbPiezas, ct.nomPiezas ),
                (self.chbDefTamRecuadro, self.sbTamRecuadro, ct.tamRecuadro ),
                (self.chbDefTamFrontera, self.sbTamFrontera, ct.tamFrontera ) ) :
            if chb.valor() :
                obj.ponValor( xv() )
                obj.setEnabled( False)
            else :
                obj.setEnabled( True)

        if self.chbDefTipoLetra.valor() :
            self.cbTipoLetra.setCurrentFont(QtGui.QFont(ct.tipoLetra()))
            self.cbTipoLetra.setEnabled( False )
        else :
            self.cbTipoLetra.setEnabled( True )

        self.siActualizando = False
    #--------------------------------------------------------------------------------------------------------------------------------
    def actualizaTableroM( self ) :
        ct = self.confTablero

        ct.ponCoordenadas( None if self.chbDefCoordenadas.valor() else self.cbCoordenadas.valor() )

        ct.ponTipoLetra( None if self.chbDefTipoLetra.valor() else self.cbTipoLetra.currentText() )

        ct.ponBold( None if self.chbDefBold.valor() else self.chbBold.valor() )

        ct.ponTamLetra( None if self.chbDefTamLetra.valor() else self.sbTamLetra.valor() )

        ct.ponSepLetras( None if self.chbDefSepLetras.valor() else self.sbSepLetras.valor() )

        ct.ponNomPiezas( None if self.chbDefPiezas.valor() else self.cbPiezas.valor() )

        ct.ponTamRecuadro( None if self.chbDefTamRecuadro.valor() else self.sbTamRecuadro.valor() )

        ct.ponTamFrontera( None if self.chbDefTamFrontera.valor() else self.sbTamFrontera.valor() )

        self.tablero.reset(ct)

    #--------------------------------------------------------------------------------------------------------------------------------
    def actualizaTablero( self ) :
        self.rehazFlechas()
        ct = self.confTablero
        self.tablero.cambiaColores(  )
        self.btExterior.ponColor( ct.colorExterior() )
        self.btBlancas.ponColor( ct.colorBlancas() )
        self.btNegras.ponColor( ct.colorNegras() )
        self.btTexto.ponColor( ct.colorTexto() )
        self.btFrontera.ponColor( ct.colorFrontera() )

    #--------------------------------------------------------------------------------------------------------------------------------
    def leeTemas( self ) :
        fichero = self.configuracion.ficheroTemas
        liTemas = Util.recuperaVar( fichero )
        return [] if liTemas is None else liTemas

    #--------------------------------------------------------------------------------------------------------------------------------
    def temas( self ) :
        siHay = len(self.liTemas) > 0
        menu = QTVarios.LCMenu()

        if siHay :
            mr = menu.submenu( _( "Open" ), Iconos.Recuperar() )
            ponMenuTemas( mr, self.liTemas, "r" )
            menu.separador()

        if self.temaActual :
            menu.opcion( "grabar", _( "Save" ) + " " + self.temaActual["NOMBRE"], Iconos.Grabar() )
            menu.separador()

        menu.opcion( "grabarComo", _( "Save as" ), Iconos.GrabarComo() )
        menu.separador()

        if siHay :
            mr = menu.submenu( _( "Remove" ), Iconos.Borrar() )
            ico = Iconos.PuntoNegro()
            for n,uno in enumerate(self.liTemas) :
                if uno :
                    mr.opcion( "b%d"%n, uno["NOMBRE"], ico )
                    mr.separador()

        resp = menu.lanza()
        if resp is None :
            return

        elif resp == "grabar" :
            self.grabarTema(self.temaActual)

        elif resp == "grabarComo" :
            tema = self.grabarTema(None)
            self.liTemas.append(tema)

        elif resp.startswith( "r" ) :
            num = int(resp[1:])
            tema = self.liTemas[num]
            self.temaActual = tema
            self.confTablero.leeTema( tema.get("TEXTO","") )
            self.actualizaTablero()

        elif resp.startswith( "b" ) :
            num = int(resp[1:])
            tema = self.liTemas[num]
            if QTUtil2.pregunta( self, _X( _("Delete %1 ?"), tema["NOMBRE"] ) ) :
                if self.temaActual == tema :
                    self.temaActual = None
                del self.liTemas[num]

        fichero = self.configuracion.ficheroTemas
        li = []
        for tema in self.liTemas :
            if tema :
                li.append(tema)
        Util.guardaVar( fichero, li )

    #--------------------------------------------------------------------------------------------------------------------------------
    def grabarTema( self, tema ) :

        liGen = [(None,None)]

        nombre = tema["NOMBRE"] if tema else ""
        config = FormLayout.Editbox( _( "Name" ), ancho=160 )
        liGen.append( (config, nombre ) )

        seccion = tema.get( "SECCION", "" ) if tema else ""
        config = FormLayout.Editbox( _( "Section" ), ancho=160 )
        liGen.append( (config, seccion ) )

        ico = Iconos.Grabar() if tema else Iconos.GrabarComo()

        resultado = FormLayout.fedit( liGen, title= _( "Name" ), parent = self, icon = ico )
        if resultado :
            accion, liResp = resultado
            nombre = liResp[0]
            seccion = liResp[1]

            if nombre :
                tema = {}
                tema["NOMBRE"] = nombre
                if seccion :
                    tema["SECCION"] = seccion
                tema["TEXTO"] = self.confTablero.grabaTema()
                self.temaActual = tema
                self.ponSecciones()
                return tema

#=========================================================================================
def cambiaColoresPGN( ventana, configuracion ) :
    liGen = [(None,None)]

    listNAGs = TrListas.listNAGs()
    config = FormLayout.Colorbox( listNAGs[1], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag1 ) )

    config = FormLayout.Colorbox( listNAGs[2], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag2 ) )

    config = FormLayout.Colorbox( listNAGs[3], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag3 ) )

    config = FormLayout.Colorbox( listNAGs[4], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag4 ) )

    config = FormLayout.Colorbox( listNAGs[5], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag5 ) )

    config = FormLayout.Colorbox( listNAGs[6], 80, 20, siSTR=True )
    liGen.append( ( config, configuracion.color_nag6 ) )

    resultado = FormLayout.fedit( liGen, title = _( "PGN" ), parent = ventana, icon = Iconos.Vista(), siDefecto = True  )
    if resultado :
        accion, liResp = resultado
        if accion == "defecto" :
            configuracion.coloresPGNdefecto()
        else :
            configuracion.color_nag1 = liResp[0]
            configuracion.color_nag2 = liResp[1]
            configuracion.color_nag3 = liResp[2]
            configuracion.color_nag4 = liResp[3]
            configuracion.color_nag5 = liResp[4]
            configuracion.color_nag6 = liResp[5]

        configuracion.graba()

#=========================================================================================
def ponMenuTemas( menuBase, liTemas, baseResp ) :

    baseResp += "%d"

    dFolders = Util.SymbolDict()
    liRoot = []
    for n,uno in enumerate(liTemas) :
        if uno :
            if "SECCION" in uno :
                folder = uno["SECCION"]
                if folder not in dFolders :
                    dFolders[folder] = []
                dFolders[folder].append( (uno, n) )
            else :
                liRoot.append( (uno,n) )
    icoFolder = Iconos.DivisionF()
    for k in dFolders :
        mf = menuBase.submenu( k, icoFolder)
        for uno, n in dFolders[k] :
            mf.opcion( baseResp%n, uno["NOMBRE"], QTVarios.iconoTema(uno,16) )
    menuBase.separador()
    for uno, n in liRoot :
        menuBase.opcion( baseResp%n, uno["NOMBRE"], QTVarios.iconoTema(uno,16) )
    menuBase.separador()

#=========================================================================================
def eligeTema( fichTema ) :

    liTemas = Util.recuperaVar( fichTema )
    if not liTemas :
        return None

    menu = QTVarios.LCMenu()

    ponMenuTemas( menu, liTemas, "" )

    resp = menu.lanza()

    return None if resp is None else liTemas[int(resp)]

